COMMENT ⊗   VALID 00004 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00002 00002	Exercise
C00004 00003	Sample Program
C00007 00004	Sample Program
C00010 ENDMK
C⊗;
Exercise

Write a program, using indefinite iterations (WHILE ... DO) only, 
that reads a sequence of positive integers terminated by a zero sentinel.
For each number  N, the program should find the smallest non-negative 
integers X and Y for which X↑2 - Y↑2 = N, or announce that there are
no such numbers.  Try the program on

21 9 180 4641 32 101 0

Watch out for non-terminating iterations (``infinite loops'').  If you have
trouble, do these problems as warmups:

(1) Read and print the input data, as above, without printing the sentinel.

(2) Read one positive number N and find  X, Y as above.

Remember, whenever you write an indefinite iteration, to find a convincing reason
to believe it will terminate.  If it isn't obvious, put it in a comment in the
program.
Sample Program

  EXAMPLE OF THE USE OF INDEFINITE ITERATION, AND INPUT FROM  
    TERMINAL.  THIS PROGRAM COMPUTES A SQUARE ROOT WITHOUT    
    USING THE STANDARD FUNCTION  `SQRT' .                     

PROGRAM DEMOWHILE ;
                                   
VAR     X,                    (* VALUE OF WHICH SQUARE ROOT IS TO
                                 BE TAKEN *)
        ROOT :  REAL ;        (* SQUARE ROOT OF X *)

BEGIN    (* HEADER AND INPUT *)
WRITELN ( TTY, ' THIS PROGRAM COMPUTES SQUARE ROOTS' ) ;
WRITELN ( TTY, ' WITHOUT USING THE BUILT-IN FUNCTION' ) ;
WRITE ( TTY, ' INPUT NUMBER : ' ) ;
BREAK ( TTY ) ;
READ ( TTY, X ) ;

(* INPUT VALIDATION *)
WHILE X < 0.0  DO
    BEGIN
    WRITELN ( TTY, ' NEGATIVE NUMBERS NOT ALLOWED ' ) ;
    WRITE ( TTY, ' TRY AGAIN : ' ) ;
    BREAK ( TTY ) ;
    READ ( TTY, X )
    END ;

(* INITIALIZATION *)
ROOT := 1.0 ;

(* COMPUTATION OF SQUARE ROOT *)
WHILE  ABS( (ROOT - X/ROOT) )  >  1.0E-6   DO
    ROOT := 0.5 * ( ROOT + X/ROOT ) ;

(* OUTPUT *)
WRITE ( TTY, ' SQUARE ROOT OF ', X :8 :4, ' IS ', ROOT :10 :6 )
END.

THIS PROGRAM COMPUTES SQUARE ROOTS
WITHOUT USING THE BUILT-IN FUNCTION
INPUT NUMBER : -2.0
NEGATIVE NUMBERS NOT ALLOWED
TRY AGAIN : 2.0
SQUARE ROOT OF  2.0000 IS  1.414213
Sample Program

  READING IN A NUMBER IN BASE 7 AND CONVERTING IT TO BASE 10  
  THIS PROGRAM HAS SOME SUBTLE POINTS TO IT:                  
      1.  THE PARENTHESES AROUND " ORD(C) - ORD(0) " TO       
          PREVENT INTEGER OVERFLOW.                           
      2.  WHEN YOU TRY TO READ A CHARACTER AT THE END OF THE  
          END OF A LINE, YOU GET A SPACE. THIS IS THE REASON  
          WHY THE PROGRAM ALWAYS STOPS AT THE END OF A LINE.  

PROGRAM CONVERT ( INPUT*, OUTPUT ) ;

VAR     C       :  CHAR ;        (* CHARACTER LAST READ IN.     *)
        VALUE   :  INTEGER ;     (* VALUE IN BASE 10.           *)

BEGIN
C := ' ' ;
WHILE ( C< '0' ) OR ( C> '6' )  DO   READ ( C ) ;
VALUE := ORD ( C ) - ORD ( '0' ) ;
READ ( C ) ;

WHILE ( C >= '0' ) AND ( C <= '6' )  DO
    BEGIN
    VALUE := VALUE*7 + ( ORD (C) - ORD ('0') ) ;
    READ ( C ) 
    END;

WRITELN ( ' DECIMAL VALUE  =  ', VALUE :8 )
END.

INPUT:  46

 DECIMAL VALUE       =       34

INPUT:  /////      23       //////

 DECIMAL VALUE       =       17